home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / ast.cpp < prev    next >
C/C++ Source or Header  |  1999-05-14  |  70KB  |  2,230 lines
  1. // $Id: ast.cpp,v 1.3 1999/01/25 20:00:26 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10.  
  11. #include "config.h"
  12. #include "unicode.h"
  13. #include "ast.h"
  14. #ifdef TEST
  15.     unsigned Ast::count = 0;
  16. #endif
  17.  
  18.  
  19. void AstCompilationUnit::FreeAst()
  20. {
  21.      delete ast_pool;
  22. }
  23.  
  24. //
  25. // This procedure uses a  quick sort algorithm to sort the cases
  26. // in a switch statement.
  27. //
  28. void AstSwitchStatement::SortCases()
  29. {
  30.      int lower,
  31.          upper,
  32.          lostack[32],
  33.          histack[32];
  34.  
  35.      int top,
  36.          i,
  37.          j;
  38.      CaseElement pivot, temp;
  39.  
  40.      top = 0;
  41.      lostack[top] = 0;
  42.      histack[top] = map.Length() - 1;
  43.  
  44.      while(top >= 0)
  45.      {
  46.          lower = lostack[top];
  47.          upper = histack[top];
  48.          top--;
  49.  
  50.          while(upper > lower)
  51.          {
  52.              //
  53.              // The array is most-likely almost sorted. Therefore,
  54.              // we use the middle element as the pivot element.
  55.              //
  56.              i = (lower + upper) / 2;
  57.              pivot = *map[i];
  58.              *map[i] = *map[lower];
  59.  
  60.              //
  61.              // Split the array section indicated by LOWER and UPPER
  62.              // using ARRAY(LOWER) as the pivot.
  63.              //
  64.              i = lower;
  65.              for (j = lower + 1; j <= upper; j++)
  66.                  if (map[j] -> Value() < pivot.Value() || 
  67.                      (map[j] -> Value() == pivot.Value() && map[j] -> index < pivot.index)) // keep the sort stable
  68.                  {
  69.                      temp = *map[++i];
  70.                      *map[i] = *map[j];
  71.                      *map[j] = temp;
  72.                  }
  73.              *map[lower] = *map[i];
  74.              *map[i] = pivot;
  75.  
  76.              top++;
  77.              if ((i - lower) < (upper - i))
  78.              {
  79.                  lostack[top] = i + 1;
  80.                  histack[top] = upper;
  81.                  upper = i - 1;
  82.              }
  83.              else
  84.              {
  85.                  histack[top] = i - 1;
  86.                  lostack[top] = lower;
  87.                  lower = i + 1;
  88.              }
  89.          }
  90.      }
  91.  
  92.      return;
  93. }
  94.  
  95.  
  96. Ast *Ast::Clone(StoragePool *ast_pool)
  97. {
  98.     return (Ast *) NULL;
  99. }
  100.  
  101. Ast *AstBlock::Clone(StoragePool *ast_pool)
  102. {
  103.     AstBlock *clone = ast_pool -> GenBlock();
  104.  
  105.     clone -> label_token_opt = this -> label_token_opt;
  106.     clone -> nesting_level = this -> nesting_level;
  107.     clone -> left_brace_token = this -> left_brace_token;
  108.     if (this -> NumStatements() == 0)
  109.         clone -> block_statements = NULL;
  110.     else
  111.     {
  112.         for (int i = 0; i < this -> NumStatements(); i++)
  113.             clone -> AddStatement(this -> Statement(i) -> Clone(ast_pool));
  114.     }
  115.     clone -> right_brace_token = this -> right_brace_token;
  116.  
  117.     return clone;
  118. }
  119.  
  120. Ast *AstPrimitiveType::Clone(StoragePool *ast_pool)
  121. {
  122.     AstPrimitiveType *clone = ast_pool -> GenPrimitiveType(this -> kind, this -> primitive_kind_token);
  123.  
  124.     return clone;
  125. }
  126.  
  127. Ast *AstArrayType::Clone(StoragePool *ast_pool)
  128. {
  129.     AstArrayType *clone = ast_pool -> GenArrayType();
  130.  
  131.     clone -> type = this -> type -> Clone(ast_pool);
  132.     clone -> AllocateBrackets(this -> NumBrackets());
  133.     for (int i = 0; i < this -> NumBrackets(); i++)
  134.         clone -> AddBrackets((AstBrackets *) this -> Brackets(i) -> Clone(ast_pool));
  135.  
  136.     return clone;
  137. }
  138.  
  139. Ast *AstSimpleName::Clone(StoragePool *ast_pool)
  140. {
  141.     AstSimpleName *clone = ast_pool -> GenSimpleName(this -> identifier_token);
  142.     clone -> resolution_opt = (AstExpression *) (this -> resolution_opt ? this -> resolution_opt -> Clone(ast_pool) : NULL);
  143.  
  144.     return clone;
  145. }
  146.  
  147. Ast *AstPackageDeclaration::Clone(StoragePool *ast_pool)
  148. {
  149.     AstPackageDeclaration *clone = ast_pool -> GenPackageDeclaration();
  150.  
  151.     clone -> package_token = this -> package_token;
  152.     clone -> name = (AstExpression *) this -> name -> Clone(ast_pool);
  153.     clone -> semicolon_token = this -> semicolon_token;
  154.  
  155.     return clone;
  156. }
  157.  
  158. Ast *AstImportDeclaration::Clone(StoragePool *ast_pool)
  159. {
  160.     AstImportDeclaration *clone = ast_pool -> GenImportDeclaration();
  161.  
  162.     clone -> import_token = this -> import_token;
  163.     clone -> name = (AstExpression *) this -> name -> Clone(ast_pool);
  164.     clone -> star_token_opt = this -> star_token_opt;
  165.     clone -> semicolon_token = this -> semicolon_token;
  166.  
  167.     return clone;
  168. }
  169.  
  170. Ast *AstCompilationUnit::Clone(StoragePool *ast_pool)
  171. {
  172.     AstCompilationUnit *clone = ast_pool -> GenCompilationUnit();
  173.  
  174.     clone -> package_declaration_opt = (AstPackageDeclaration *)
  175.                                        (this -> package_declaration_opt
  176.                                               ? this -> package_declaration_opt -> Clone(ast_pool) : NULL);
  177.     for (int i = 0; i < this -> NumImportDeclarations(); i++)
  178.         clone -> AddImportDeclaration((AstImportDeclaration *) this -> ImportDeclaration(i) -> Clone(ast_pool));
  179.     for (int k = 0; k < this -> NumTypeDeclarations(); k++)
  180.         clone -> AddTypeDeclaration(this -> TypeDeclaration(k) -> Clone(ast_pool));
  181.  
  182.     return clone;
  183. }
  184.  
  185. Ast *AstModifier::Clone(StoragePool *ast_pool)
  186. {
  187.     AstModifier *clone = ast_pool -> GenModifier(this -> kind, this -> modifier_kind_token);
  188.  
  189.     return clone;
  190. }
  191.  
  192. Ast *AstEmptyDeclaration::Clone(StoragePool *ast_pool)
  193. {
  194.     AstEmptyDeclaration *clone = ast_pool -> GenEmptyDeclaration(this -> semicolon_token);
  195.  
  196.     return clone;
  197. }
  198.  
  199. Ast *AstClassBody::Clone(StoragePool *ast_pool)
  200. {
  201.     AstClassBody *clone = ast_pool -> GenClassBody();
  202.  
  203.     clone -> left_brace_token = this -> left_brace_token;
  204.     for (int i = 0; i < this -> NumClassBodyDeclarations(); i++)
  205.         clone -> AddClassBodyDeclaration(this -> ClassBodyDeclaration(i) -> Clone(ast_pool));
  206.     clone -> right_brace_token = this -> right_brace_token;
  207.  
  208.     return clone;
  209. }
  210.  
  211. Ast *AstClassDeclaration::Clone(StoragePool *ast_pool)
  212. {
  213.     AstClassDeclaration *clone = ast_pool -> GenClassDeclaration();
  214.  
  215.     for (int i = 0; i < this -> NumClassModifiers(); i++)
  216.         clone -> AddClassModifier((AstModifier *) this -> ClassModifier(i) -> Clone(ast_pool));
  217.     clone -> class_token = this -> class_token;
  218.     clone -> identifier_token = this -> identifier_token;
  219.     clone -> super_opt = (Ast *) (this -> super_opt ? this -> super_opt -> Clone(ast_pool) : NULL); 
  220.     for (int k = 0; k < this -> NumInterfaces(); k++)
  221.         clone -> AddInterface((AstExpression *) this -> Interface(k) -> Clone(ast_pool));
  222.     clone -> class_body = (AstClassBody *) this -> class_body -> Clone(ast_pool);
  223.  
  224.     return clone;
  225. }
  226.  
  227. Ast *AstArrayInitializer::Clone(StoragePool *ast_pool)
  228. {
  229.     AstArrayInitializer *clone = ast_pool -> GenArrayInitializer();
  230.  
  231.     clone -> left_brace_token = this -> left_brace_token;
  232.     for (int k = 0; k < this -> NumVariableInitializers(); k++)
  233.         clone -> AddVariableInitializer(this -> VariableInitializer(k) -> Clone(ast_pool));
  234.     clone -> right_brace_token = this -> right_brace_token;
  235.  
  236.     return clone;
  237. }
  238.  
  239. Ast *AstBrackets::Clone(StoragePool *ast_pool)
  240. {
  241.     AstBrackets *clone = ast_pool -> GenBrackets(this -> left_bracket_token, this -> right_bracket_token);
  242.  
  243.     return clone;
  244. }
  245.  
  246. Ast *AstVariableDeclaratorId::Clone(StoragePool *ast_pool)
  247. {
  248.     AstVariableDeclaratorId *clone = ast_pool -> GenVariableDeclaratorId();
  249.  
  250.     clone -> identifier_token = this -> identifier_token;
  251.     clone -> AllocateBrackets(this -> NumBrackets());
  252.     for (int i = 0; i < this -> NumBrackets(); i++)
  253.         clone -> AddBrackets((AstBrackets *) this -> Brackets(i) -> Clone(ast_pool));
  254.  
  255.     return clone;
  256. }
  257.  
  258. Ast *AstVariableDeclarator::Clone(StoragePool *ast_pool)
  259. {
  260.     AstVariableDeclarator *clone = ast_pool -> GenVariableDeclarator();
  261.  
  262.     clone -> variable_declarator_name = (AstVariableDeclaratorId *) this -> variable_declarator_name -> Clone(ast_pool);
  263.     clone -> variable_initializer_opt = (Ast *) (this -> variable_initializer_opt
  264.                                                        ? this -> variable_initializer_opt -> Clone(ast_pool)
  265.                                                        : NULL);
  266.  
  267.     return clone;
  268. }
  269.  
  270. Ast *AstFieldDeclaration::Clone(StoragePool *ast_pool)
  271. {
  272.     AstFieldDeclaration *clone = ast_pool -> GenFieldDeclaration();
  273.  
  274.     for (int i = 0; i < this -> NumVariableModifiers(); i++)
  275.         clone -> AddVariableModifier((AstModifier *) this -> VariableModifier(i) -> Clone(ast_pool));
  276.     clone -> type = this -> type -> Clone(ast_pool);
  277.     for (int k = 0; k < this -> NumVariableDeclarators(); k++)
  278.         clone -> AddVariableDeclarator((AstVariableDeclarator *) this -> VariableDeclarator(k) -> Clone(ast_pool));
  279.     clone -> semicolon_token = this -> semicolon_token;
  280.  
  281.     return clone;
  282. }
  283.  
  284. Ast *AstFormalParameter::Clone(StoragePool *ast_pool)
  285. {
  286.     AstFormalParameter *clone = ast_pool -> GenFormalParameter();
  287.  
  288.     if (this -> NumParameterModifiers() == 0)
  289.         clone -> parameter_modifiers = NULL;
  290.     else
  291.     {
  292.         for (int i = 0; i < this -> NumParameterModifiers(); i++)
  293.             clone -> AddParameterModifier((AstModifier *) this -> ParameterModifier(i) -> Clone(ast_pool));
  294.     }
  295.     clone -> type = this -> type -> Clone(ast_pool);
  296.     clone -> variable_declarator_name = (AstVariableDeclaratorId *) this -> variable_declarator_name -> Clone(ast_pool);
  297.  
  298.     return clone;
  299. }
  300.  
  301. Ast *AstMethodDeclarator::Clone(StoragePool *ast_pool)
  302. {
  303.     AstMethodDeclarator *clone = ast_pool -> GenMethodDeclarator();
  304.  
  305.     clone -> identifier_token = this -> identifier_token;
  306.     clone -> left_parenthesis_token = this -> left_parenthesis_token;
  307.     clone -> AllocateFormalParameters(this -> NumFormalParameters());
  308.     for (int i = 0; i < this -> NumFormalParameters(); i++)
  309.         clone -> AddFormalParameter((AstFormalParameter *) this -> FormalParameter(i) -> Clone(ast_pool));
  310.     clone -> right_parenthesis_token = this -> right_parenthesis_token;
  311.     clone -> AllocateBrackets(this -> NumBrackets());
  312.     for (int k = 0; k < this -> NumBrackets(); k++)
  313.         clone -> AddBrackets((AstBrackets *) this -> Brackets(k) -> Clone(ast_pool));
  314.  
  315.     return clone;
  316. }
  317.  
  318. Ast *AstMethodDeclaration::Clone(StoragePool *ast_pool)
  319. {
  320.     AstMethodDeclaration *clone = ast_pool -> GenMethodDeclaration();
  321.  
  322.     for (int i = 0; i < this -> NumMethodModifiers(); i++)
  323.         clone -> AddMethodModifier((AstModifier *) this -> MethodModifier(i) -> Clone(ast_pool));
  324.     clone -> type = this -> type -> Clone(ast_pool);
  325.     clone -> method_declarator = (AstMethodDeclarator *) this -> method_declarator -> Clone(ast_pool);
  326.     for (int k = 0; k < this -> NumThrows(); k++)
  327.         clone -> AddThrow((AstExpression *) this -> Throw(k) -> Clone(ast_pool));
  328.     clone -> method_body = (AstStatement *) this -> method_body -> Clone(ast_pool);
  329.  
  330.     return clone;
  331. }
  332.  
  333. Ast *AstStaticInitializer::Clone(StoragePool *ast_pool)
  334. {
  335.     AstStaticInitializer *clone = ast_pool -> GenStaticInitializer();
  336.  
  337.     clone -> static_token = this -> static_token;
  338.     clone -> block = (AstBlock *) this -> block -> Clone(ast_pool);
  339.  
  340.     return clone;
  341. }
  342.  
  343. Ast *AstThisCall::Clone(StoragePool *ast_pool)
  344. {
  345.     AstThisCall *clone = ast_pool -> GenThisCall();
  346.  
  347.     clone -> this_token = this -> this_token;
  348.     clone -> left_parenthesis_token = this -> left_parenthesis_token;
  349.     clone -> AllocateArguments(this -> NumArguments());
  350.     for (int i = 0; i < this -> NumArguments(); i++)
  351.         clone -> AddArgument((AstExpression *) this -> Argument(i) -> Clone(ast_pool));
  352.     clone -> right_parenthesis_token = this -> right_parenthesis_token;
  353.     clone -> semicolon_token = this -> semicolon_token;
  354.  
  355.     return clone;
  356. }
  357.  
  358. Ast *AstSuperCall::Clone(StoragePool *ast_pool)
  359. {
  360.     AstSuperCall *clone = ast_pool -> GenSuperCall();
  361.  
  362.     clone -> base_opt = (AstExpression *) (this -> base_opt ? this -> base_opt -> Clone(ast_pool) : NULL);
  363.     clone -> dot_token_opt = this -> dot_token_opt;
  364.     clone -> super_token = this -> super_token;
  365.     clone -> left_parenthesis_token = this -> left_parenthesis_token;
  366.     clone -> AllocateArguments(this -> NumArguments());
  367.     for (int i = 0; i < this -> NumArguments(); i++)
  368.         clone -> AddArgument((AstExpression *) this -> Argument(i) -> Clone(ast_pool));
  369.     clone -> right_parenthesis_token = this -> right_parenthesis_token;
  370.     clone -> semicolon_token = this -> semicolon_token;
  371.     clone -> AllocateLocalArguments(this -> NumLocalArguments());
  372.     for (int k = 0; k < this -> NumLocalArguments(); k++)
  373.         clone -> AddLocalArgument((AstExpression *) this -> LocalArgument(k) -> Clone(ast_pool));
  374.  
  375.     return clone;
  376. }
  377.  
  378. Ast *AstConstructorBlock::Clone(StoragePool *ast_pool)
  379. {
  380.     AstConstructorBlock *clone = ast_pool -> GenConstructorBlock();
  381.  
  382.     clone -> left_brace_token = this -> left_brace_token;
  383.     clone -> explicit_constructor_invocation_opt = (Ast *) 
  384.                                                    (this -> explicit_constructor_invocation_opt
  385.                                                           ? this -> explicit_constructor_invocation_opt -> Clone(ast_pool)
  386.                                                           : NULL);
  387.     clone -> block = (AstBlock *) this -> block -> Clone(ast_pool);
  388.     clone -> right_brace_token = this -> right_brace_token;
  389.  
  390.     return clone;
  391. }
  392.  
  393. Ast *AstConstructorDeclaration::Clone(StoragePool *ast_pool)
  394. {
  395.     AstConstructorDeclaration *clone = ast_pool -> GenConstructorDeclaration();
  396.  
  397.     for (int i = 0; i < this -> NumConstructorModifiers(); i++)
  398.         clone -> AddConstructorModifier((AstModifier *) this -> ConstructorModifier(i) -> Clone(ast_pool));
  399.     clone -> constructor_declarator = (AstMethodDeclarator *) this -> constructor_declarator -> Clone(ast_pool);
  400.     for (int k = 0; k < this -> NumThrows(); k++)
  401.         clone -> AddThrow((AstExpression *) this -> Throw(k) -> Clone(ast_pool));
  402.     clone -> constructor_body = (AstConstructorBlock *) this -> constructor_body -> Clone(ast_pool);
  403.  
  404.     return clone;
  405. }
  406.  
  407. Ast *AstInterfaceDeclaration::Clone(StoragePool *ast_pool)
  408. {
  409.     AstInterfaceDeclaration *clone = ast_pool -> GenInterfaceDeclaration();
  410.  
  411.     for (int i = 0; i < this -> NumInterfaceModifiers(); i++)
  412.         clone -> AddInterfaceModifier((AstModifier *) this -> InterfaceModifier(i) -> Clone(ast_pool));
  413.     clone -> interface_token = this -> interface_token;
  414.     clone -> identifier_token = this -> identifier_token;
  415.     for (int k = 0; k < this -> NumExtendsInterfaces(); k++)
  416.         clone -> AddExtendsInterface((AstExpression *) this -> ExtendsInterface(k) -> Clone(ast_pool));
  417.     clone -> left_brace_token = this -> left_brace_token;
  418.     for (int l = 0; l < this -> NumExtendsInterfaces(); l++)
  419.         clone -> AddInterfaceMemberDeclaration((AstExpression *) this -> InterfaceMemberDeclaration(l) -> Clone(ast_pool));
  420.     clone -> right_brace_token = this -> right_brace_token;
  421.  
  422.     return clone;
  423. }
  424.  
  425. Ast *AstLocalVariableDeclarationStatement::Clone(StoragePool *ast_pool)
  426. {
  427.     AstLocalVariableDeclarationStatement *clone = ast_pool -> GenLocalVariableDeclarationStatement();
  428.  
  429.     for (int i = 0; i < this -> NumLocalModifiers(); i++)
  430.         clone -> AddLocalModifier((AstModifier *) this -> LocalModifier(i) -> Clone(ast_pool));
  431.     clone -> type = this -> type -> Clone(ast_pool);
  432.     for (int k = 0; k < this -> NumVariableDeclarators(); k++)
  433.         clone -> AddVariableDeclarator((AstVariableDeclarator *) this -> VariableDeclarator(k) -> Clone(ast_pool));
  434.     clone -> semicolon_token_opt = this -> semicolon_token_opt;
  435.  
  436.     return clone;
  437. }
  438.  
  439. Ast *AstIfStatement::Clone(StoragePool *ast_pool)
  440. {
  441.     AstIfStatement *clone = ast_pool -> GenIfStatement();
  442.  
  443.     clone -> if_token = this -> if_token;
  444.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  445.     clone -> true_statement = (AstStatement *) this -> true_statement -> Clone(ast_pool);
  446.     clone -> false_statement_opt = (AstStatement *) 
  447.                                    (this -> false_statement_opt
  448.                                           ? this -> false_statement_opt -> Clone(ast_pool)
  449.                                           : NULL);
  450.  
  451.     return clone;
  452. }
  453.  
  454. Ast *AstEmptyStatement::Clone(StoragePool *ast_pool)
  455. {
  456.     AstEmptyStatement *clone = ast_pool -> GenEmptyStatement(this -> semicolon_token);
  457.  
  458.     return clone;
  459. }
  460.  
  461. Ast *AstExpressionStatement::Clone(StoragePool *ast_pool)
  462. {
  463.     AstExpressionStatement *clone = ast_pool -> GenExpressionStatement();
  464.  
  465.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  466.     clone -> semicolon_token_opt = this -> semicolon_token_opt;
  467.  
  468.     return clone;
  469. }
  470.  
  471. Ast *AstCaseLabel::Clone(StoragePool *ast_pool)
  472. {
  473.     AstCaseLabel *clone = ast_pool -> GenCaseLabel();
  474.  
  475.     clone -> case_token = this -> case_token;
  476.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  477.     clone -> colon_token = this -> colon_token;
  478.     clone -> map_index = this -> map_index;
  479.  
  480.     return clone;
  481. }
  482.  
  483. Ast *AstDefaultLabel::Clone(StoragePool *ast_pool)
  484. {
  485.     AstDefaultLabel *clone = ast_pool -> GenDefaultLabel();
  486.  
  487.     clone -> default_token = this -> default_token;
  488.     clone -> colon_token = this -> colon_token;
  489.  
  490.     return clone;
  491. }
  492.  
  493. Ast *AstSwitchBlockStatement::Clone(StoragePool *ast_pool)
  494. {
  495.     AstSwitchBlockStatement *clone = ast_pool -> GenSwitchBlockStatement();
  496.  
  497.     clone -> AllocateSwitchLabels(this -> NumSwitchLabels());
  498.     for (int i = 0; i < this -> NumSwitchLabels(); i++)
  499.         clone -> AddSwitchLabel(this -> SwitchLabel(i) -> Clone(ast_pool));
  500.  
  501.     clone -> AllocateBlockStatements(this -> NumStatements());
  502.     for (int k = 0; k < this -> NumStatements(); k++)
  503.         clone -> AddStatement((AstStatement *) this -> Statement(k) -> Clone(ast_pool));
  504.  
  505.     return clone;
  506. }
  507.  
  508. Ast *AstSwitchStatement::Clone(StoragePool *ast_pool)
  509. {
  510.     AstSwitchStatement *clone = ast_pool -> GenSwitchStatement();
  511.  
  512.     clone -> switch_token = this -> switch_token;
  513.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  514.     clone -> switch_block = (AstBlock *) this -> switch_block -> Clone(ast_pool);
  515.  
  516.     return clone;
  517. }
  518.  
  519. Ast *AstWhileStatement::Clone(StoragePool *ast_pool)
  520. {
  521.     AstWhileStatement *clone = ast_pool -> GenWhileStatement();
  522.  
  523.     clone -> while_token = this -> while_token;
  524.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  525.     clone -> statement = (AstStatement *) this -> statement -> Clone(ast_pool);
  526.  
  527.     return clone;
  528. }
  529.  
  530. Ast *AstDoStatement::Clone(StoragePool *ast_pool)
  531. {
  532.     AstDoStatement *clone = ast_pool -> GenDoStatement();
  533.  
  534.     clone -> do_token = this -> do_token;
  535.     clone -> statement = (AstStatement *) this -> statement -> Clone(ast_pool);
  536.     clone -> while_token = this -> while_token;
  537.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  538.     clone -> semicolon_token = this -> semicolon_token;
  539.  
  540.     return clone;
  541. }
  542.  
  543. Ast *AstForStatement::Clone(StoragePool *ast_pool)
  544. {
  545.     AstForStatement *clone = ast_pool -> GenForStatement();
  546.  
  547.     clone -> for_token = this -> for_token;
  548.     for (int i = 0; i < this -> NumForInitStatements(); i++)
  549.         clone -> AddForInitStatement((AstStatement *) this -> ForInitStatement(i) -> Clone(ast_pool));
  550.     clone -> end_expression_opt = (AstExpression *)
  551.                                   (this -> end_expression_opt
  552.                                          ? this -> end_expression_opt -> Clone(ast_pool)
  553.                                          : NULL);
  554.     for (int k = 0; k < this -> NumForUpdateStatements(); k++)
  555.         clone -> AddForUpdateStatement((AstExpressionStatement *) this -> ForUpdateStatement(k) -> Clone(ast_pool));
  556.     clone -> statement = (AstStatement *) this -> statement -> Clone(ast_pool);
  557.  
  558.     return clone;
  559. }
  560.  
  561. Ast *AstBreakStatement::Clone(StoragePool *ast_pool)
  562. {
  563.     AstBreakStatement *clone = ast_pool -> GenBreakStatement();
  564.  
  565.     clone -> break_token = this -> break_token;
  566.     clone -> identifier_token_opt = this -> identifier_token_opt;
  567.     clone -> semicolon_token = this -> semicolon_token;
  568.     clone -> nesting_level = this -> nesting_level;
  569.  
  570.     return clone;
  571. }
  572.  
  573. Ast *AstContinueStatement::Clone(StoragePool *ast_pool)
  574. {
  575.     AstContinueStatement *clone = ast_pool -> GenContinueStatement();
  576.  
  577.     clone -> continue_token = this -> continue_token;
  578.     clone -> identifier_token_opt = this -> identifier_token_opt;
  579.     clone -> semicolon_token = this -> semicolon_token;
  580.     clone -> nesting_level = this -> nesting_level;
  581.  
  582.     return clone;
  583. }
  584.  
  585. Ast *AstReturnStatement::Clone(StoragePool *ast_pool)
  586. {
  587.     AstReturnStatement *clone = ast_pool -> GenReturnStatement();
  588.  
  589.     clone -> return_token = this -> return_token;
  590.     clone -> expression_opt = (AstExpression *) (this -> expression_opt ? this -> expression_opt -> Clone(ast_pool) : NULL);
  591.     clone -> semicolon_token = this -> semicolon_token;
  592.  
  593.     return clone;
  594. }
  595.  
  596. Ast *AstThrowStatement::Clone(StoragePool *ast_pool)
  597. {
  598.     AstThrowStatement *clone = ast_pool -> GenThrowStatement();
  599.  
  600.     clone -> throw_token = this -> throw_token;
  601.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  602.     clone -> semicolon_token = this -> semicolon_token;
  603.  
  604.     return clone;
  605. }
  606.  
  607. Ast *AstSynchronizedStatement::Clone(StoragePool *ast_pool)
  608. {
  609.     AstSynchronizedStatement *clone = ast_pool -> GenSynchronizedStatement();
  610.  
  611.     clone -> synchronized_token = this -> synchronized_token;
  612.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  613.     clone -> block = (AstBlock *) this -> block -> Clone(ast_pool);
  614.  
  615.     return clone;
  616. }
  617.  
  618. Ast *AstCatchClause::Clone(StoragePool *ast_pool)
  619. {
  620.     AstCatchClause *clone = ast_pool -> GenCatchClause();
  621.  
  622.     clone -> catch_token = this -> catch_token;
  623.     clone -> formal_parameter = (AstFormalParameter *) this -> formal_parameter -> Clone(ast_pool);
  624.     clone -> block = (AstBlock *) this -> block -> Clone(ast_pool);
  625.  
  626.     return clone;
  627. }
  628.  
  629. Ast *AstFinallyClause::Clone(StoragePool *ast_pool)
  630. {
  631.     AstFinallyClause *clone = ast_pool -> GenFinallyClause();
  632.  
  633.     clone -> finally_token = this -> finally_token;
  634.     clone -> block = (AstBlock *) this -> block -> Clone(ast_pool);
  635.  
  636.     return clone;
  637. }
  638.  
  639. Ast *AstTryStatement::Clone(StoragePool *ast_pool)
  640. {
  641.     AstTryStatement *clone = ast_pool -> GenTryStatement();
  642.  
  643.     clone -> try_token = this -> try_token;
  644.     clone -> block = (AstBlock *) this -> block -> Clone(ast_pool);
  645.     for (int k = 0; k < this -> NumCatchClauses(); k++)
  646.         clone -> AddCatchClause((AstCatchClause *) this -> CatchClause(k) -> Clone(ast_pool));
  647.     clone -> finally_clause_opt = (AstFinallyClause *)
  648.                                   (this -> finally_clause_opt
  649.                                          ? this -> finally_clause_opt -> Clone(ast_pool)
  650.                                          : NULL);
  651.  
  652.     return clone;
  653. }
  654.  
  655. Ast *AstIntegerLiteral::Clone(StoragePool *ast_pool)
  656. {
  657.     AstIntegerLiteral *clone = ast_pool -> GenIntegerLiteral(this -> integer_literal_token);
  658.  
  659.     return clone;
  660. }
  661.  
  662. Ast *AstLongLiteral::Clone(StoragePool *ast_pool)
  663. {
  664.     AstLongLiteral *clone = ast_pool -> GenLongLiteral(this -> long_literal_token);
  665.  
  666.     return clone;
  667. }
  668.  
  669. Ast *AstFloatingPointLiteral::Clone(StoragePool *ast_pool)
  670. {
  671.     AstFloatingPointLiteral *clone = ast_pool -> GenFloatingPointLiteral(this -> floating_point_literal_token);
  672.  
  673.     return clone;
  674. }
  675.  
  676. Ast *AstDoubleLiteral::Clone(StoragePool *ast_pool)
  677. {
  678.     AstDoubleLiteral *clone = ast_pool -> GenDoubleLiteral(this -> double_literal_token);
  679.  
  680.     return clone;
  681. }
  682.  
  683. Ast *AstTrueLiteral::Clone(StoragePool *ast_pool)
  684. {
  685.     AstTrueLiteral *clone = ast_pool -> GenTrueLiteral(this -> true_literal_token);
  686.  
  687.     return clone;
  688. }
  689.  
  690. Ast *AstFalseLiteral::Clone(StoragePool *ast_pool)
  691. {
  692.     AstFalseLiteral *clone = ast_pool -> GenFalseLiteral(this -> false_literal_token);
  693.  
  694.     return clone;
  695. }
  696.  
  697. Ast *AstStringLiteral::Clone(StoragePool *ast_pool)
  698. {
  699.     AstStringLiteral *clone = ast_pool -> GenStringLiteral(this -> string_literal_token);
  700.  
  701.     return clone;
  702. }
  703.  
  704. Ast *AstCharacterLiteral::Clone(StoragePool *ast_pool)
  705. {
  706.     AstCharacterLiteral *clone = ast_pool -> GenCharacterLiteral(this -> character_literal_token);
  707.  
  708.     return clone;
  709. }
  710.  
  711. Ast *AstNullLiteral::Clone(StoragePool *ast_pool)
  712. {
  713.     AstNullLiteral *clone = ast_pool -> GenNullLiteral(this -> null_token);
  714.  
  715.     return clone;
  716. }
  717.  
  718. Ast *AstThisExpression::Clone(StoragePool *ast_pool)
  719. {
  720.     AstThisExpression *clone = ast_pool -> GenThisExpression(this -> this_token);
  721.  
  722.     return clone;
  723. }
  724.  
  725. Ast *AstSuperExpression::Clone(StoragePool *ast_pool)
  726. {
  727.     AstSuperExpression *clone = ast_pool -> GenSuperExpression(this -> super_token);
  728.  
  729.     return clone;
  730. }
  731.  
  732. Ast *AstParenthesizedExpression::Clone(StoragePool *ast_pool)
  733. {
  734.     AstParenthesizedExpression *clone = ast_pool -> GenParenthesizedExpression();
  735.  
  736.     clone -> left_parenthesis_token = this -> left_parenthesis_token;
  737.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  738.     clone -> right_parenthesis_token = this -> right_parenthesis_token;
  739.  
  740.     return clone;
  741. }
  742.  
  743. Ast *AstTypeExpression::Clone(StoragePool *ast_pool)
  744. {
  745.     AstTypeExpression *clone = ast_pool -> GenTypeExpression(this -> type -> Clone(ast_pool));
  746.  
  747.     return clone;
  748. }
  749.  
  750. Ast *AstClassInstanceCreationExpression::Clone(StoragePool *ast_pool)
  751. {
  752.     AstClassInstanceCreationExpression *clone = ast_pool -> GenClassInstanceCreationExpression();
  753.  
  754.     clone -> base_opt = (AstExpression *) (this -> base_opt ? this -> base_opt -> Clone(ast_pool) : NULL);
  755.     clone -> dot_token_opt = this -> dot_token_opt;
  756.     clone -> new_token = this -> new_token;
  757.     clone -> class_type = (AstTypeExpression *) this -> class_type -> Clone(ast_pool);
  758.     clone -> left_parenthesis_token = this -> left_parenthesis_token;
  759.     clone -> AllocateArguments(this -> NumArguments());
  760.     for (int i = 0; i < this -> NumArguments(); i++)
  761.         clone -> AddArgument((AstExpression *) this -> Argument(i) -> Clone(ast_pool));
  762.     clone -> right_parenthesis_token = this -> right_parenthesis_token;
  763.     clone -> class_body_opt = (AstClassBody *) (this -> class_body_opt ? this -> class_body_opt -> Clone(ast_pool) : NULL);
  764.     clone -> AllocateLocalArguments(this -> NumLocalArguments());
  765.     for (int k = 0; k < this -> NumLocalArguments(); k++)
  766.         clone -> AddLocalArgument((AstExpression *) this -> LocalArgument(k) -> Clone(ast_pool));
  767.  
  768.     return clone;
  769. }
  770.  
  771. Ast *AstDimExpr::Clone(StoragePool *ast_pool)
  772. {
  773.     AstDimExpr *clone = ast_pool -> GenDimExpr();
  774.  
  775.     clone -> left_bracket_token = this -> left_bracket_token;
  776.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  777.     clone -> right_bracket_token = this -> right_bracket_token;
  778.  
  779.     return clone;
  780. }
  781.  
  782. Ast *AstArrayCreationExpression::Clone(StoragePool *ast_pool)
  783. {
  784.     AstArrayCreationExpression *clone = ast_pool -> GenArrayCreationExpression();
  785.  
  786.     clone -> new_token = this -> new_token;
  787.     clone -> array_type = this -> array_type -> Clone(ast_pool);
  788.     clone -> AllocateDimExprs(this -> NumDimExprs());
  789.     for (int i = 0; i < this -> NumDimExprs(); i++)
  790.         clone -> AddDimExpr((AstDimExpr *) this -> DimExpr(i) -> Clone(ast_pool));
  791.     clone -> AllocateBrackets(this -> NumBrackets());
  792.     for (int k = 0; k < this -> NumBrackets(); k++)
  793.         clone -> AddBrackets((AstBrackets *) this -> Brackets(k) -> Clone(ast_pool));
  794.     clone -> array_initializer_opt = (AstArrayInitializer *)
  795.                                      (this -> array_initializer_opt ? this -> array_initializer_opt -> Clone(ast_pool) : NULL);
  796.  
  797.     return clone;
  798. }
  799.  
  800. Ast *AstFieldAccess::Clone(StoragePool *ast_pool)
  801. {
  802.     AstFieldAccess *clone = ast_pool -> GenFieldAccess();
  803.  
  804.     clone -> base = (AstExpression *) this -> base -> Clone(ast_pool);
  805.     clone -> dot_token = this -> dot_token;
  806.     clone -> identifier_token = this -> identifier_token;
  807.     clone -> resolution_opt = (AstExpression *) (this -> resolution_opt ? this -> resolution_opt -> Clone(ast_pool) : NULL);
  808.  
  809.     return clone;
  810. }
  811.  
  812. Ast *AstMethodInvocation::Clone(StoragePool *ast_pool)
  813. {
  814.     AstMethodInvocation *clone = ast_pool -> GenMethodInvocation();
  815.  
  816.     clone -> method = (AstExpression *) this -> method -> Clone(ast_pool);
  817.     clone -> left_parenthesis_token = this -> left_parenthesis_token;
  818.     clone -> AllocateArguments(this -> NumArguments());
  819.     for (int i = 0; i < this -> NumArguments(); i++)
  820.         clone -> AddArgument((AstExpression *) this -> Argument(i) -> Clone(ast_pool));
  821.     clone -> right_parenthesis_token = this -> right_parenthesis_token;
  822.  
  823.     return clone;
  824. }
  825.  
  826. Ast *AstArrayAccess::Clone(StoragePool *ast_pool)
  827. {
  828.     AstArrayAccess *clone = ast_pool -> GenArrayAccess();
  829.  
  830.     clone -> base = (AstExpression *) this -> base -> Clone(ast_pool);
  831.     clone -> left_bracket_token = this -> left_bracket_token;
  832.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  833.     clone -> right_bracket_token = this -> right_bracket_token;
  834.  
  835.     return clone;
  836. }
  837.  
  838. Ast *AstPostUnaryExpression::Clone(StoragePool *ast_pool)
  839. {
  840.     AstPostUnaryExpression *clone = ast_pool -> GenPostUnaryExpression(this -> post_unary_tag);
  841.  
  842.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  843.     clone -> post_operator_token = this -> post_operator_token;
  844.  
  845.     return clone;
  846. }
  847.  
  848. Ast *AstPreUnaryExpression::Clone(StoragePool *ast_pool)
  849. {
  850.     AstPreUnaryExpression *clone = ast_pool -> GenPreUnaryExpression(this -> pre_unary_tag);
  851.  
  852.     clone -> pre_operator_token = this -> pre_operator_token;
  853.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  854.  
  855.     return clone;
  856. }
  857.  
  858. Ast *AstCastExpression::Clone(StoragePool *ast_pool)
  859. {
  860.     AstCastExpression *clone = ast_pool -> GenCastExpression();
  861.  
  862.     clone -> left_parenthesis_token_opt = this -> left_parenthesis_token_opt;
  863.     clone -> type_opt = (Ast *) (this -> type_opt ? this -> type_opt -> Clone(ast_pool) : NULL);
  864.     clone -> AllocateBrackets(this -> NumBrackets());
  865.     for (int i = 0; i < this -> NumBrackets(); i++)
  866.         clone -> AddBrackets((AstBrackets *) this -> Brackets(i) -> Clone(ast_pool));
  867.     clone -> right_parenthesis_token_opt = this -> right_parenthesis_token_opt;
  868.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  869.  
  870.     return clone;
  871. }
  872.  
  873. Ast *AstBinaryExpression::Clone(StoragePool *ast_pool)
  874. {
  875.     AstBinaryExpression *clone = ast_pool -> GenBinaryExpression(this -> binary_tag);
  876.  
  877.     clone -> left_expression = (AstExpression *) this -> left_expression -> Clone(ast_pool);
  878.     clone -> binary_operator_token = this -> binary_operator_token;
  879.     clone -> right_expression = (AstExpression *) this -> right_expression -> Clone(ast_pool);
  880.  
  881.     return clone;
  882. }
  883.  
  884. Ast *AstConditionalExpression::Clone(StoragePool *ast_pool)
  885. {
  886.     AstConditionalExpression *clone = ast_pool -> GenConditionalExpression();
  887.  
  888.     clone -> test_expression = (AstExpression *) this -> test_expression -> Clone(ast_pool);
  889.     clone -> question_token = this -> question_token;
  890.     clone -> true_expression = (AstExpression *) this -> true_expression -> Clone(ast_pool);
  891.     clone -> colon_token = this -> colon_token;
  892.     clone -> false_expression = (AstExpression *) this -> false_expression -> Clone(ast_pool);
  893.  
  894.     return clone;
  895. }
  896.  
  897. Ast *AstAssignmentExpression::Clone(StoragePool *ast_pool)
  898. {
  899.     AstAssignmentExpression *clone = ast_pool -> GenAssignmentExpression(this -> assignment_tag, this -> assignment_operator_token);
  900.  
  901.     clone -> left_hand_side = (AstExpression *) this -> left_hand_side -> Clone(ast_pool);
  902.     clone -> expression = (AstExpression *) this -> expression -> Clone(ast_pool);
  903.  
  904.     return clone;
  905. }
  906.  
  907. #ifdef TEST
  908.     void Ast::Print(LexStream& lex_stream)
  909.     {
  910.         cout << "#" << this -> id << " (Ast):  ";
  911.         cout << "Node number " << (int) kind << " does not contain a print routine\n";
  912.     }
  913.  
  914.     void AstBlock::Print(LexStream& lex_stream)
  915.     {
  916.         cout << "#" << this -> id << " (";
  917.         Unicode::Cout(label_token_opt ? lex_stream.Name(label_token_opt) : L"");
  918.         cout << (label_token_opt ? ": " : "")
  919.              << "Block at level " << nesting_level  
  920.              << ", max_variable_index " << block_symbol -> max_variable_index 
  921.              << ", try_variable_index " << block_symbol -> try_variable_index 
  922.              << ")";
  923.  
  924.         if (NumStatements() > 0)
  925.         {
  926.             cout << "    {";
  927.             for (int i = 0; i < this -> NumStatements(); i++)
  928.             {
  929.                 if (i % 10 == 0)
  930.                     cout << "\n        ";
  931.                 cout << " #" << this -> Statement(i) -> id;
  932.             }
  933.             cout << "    }";
  934.             for (int k = 0; k < this -> NumStatements(); k++)
  935.                 this -> Statement(k) -> Print(lex_stream);
  936.         }
  937.         cout <<"\n";
  938.     }
  939.  
  940.     void AstPrimitiveType::Print(LexStream& lex_stream)
  941.     {
  942.         cout << "#" << this -> id << " (PrimitiveType):  ";
  943.         Unicode::Cout(lex_stream.Name(primitive_kind_token));
  944.         cout << "\n";
  945.     }
  946.  
  947.     void AstArrayType::Print(LexStream& lex_stream)
  948.     {
  949.         cout << "#" << this -> id << " (ArrayType):  "
  950.              << "#" << type -> id;
  951.         for (int i = 0; i < this -> NumBrackets(); i++)
  952.              cout << " []";
  953.         cout << "\n";
  954.         type -> Print(lex_stream);
  955.     }
  956.  
  957.     void AstSimpleName::Print(LexStream& lex_stream)
  958.     {
  959.         cout << "#" << this -> id << " (SimpleName):  ";
  960.         Unicode::Cout(lex_stream.Name(identifier_token));
  961.         cout << "\n";
  962.     }
  963.  
  964.     void AstPackageDeclaration::Print(LexStream& lex_stream)
  965.     {
  966.         cout << "#" << this -> id << " (PackageDeclaration):  ";
  967.         Unicode::Cout(lex_stream.Name(package_token));
  968.         cout << " #" << name -> id << "\n";
  969.         name -> Print(lex_stream);
  970.     }
  971.  
  972.     void AstImportDeclaration::Print(LexStream& lex_stream)
  973.     {
  974.         cout << "#" << this -> id << " (ImportDeclaration):  ";
  975.         Unicode::Cout(lex_stream.Name(import_token));
  976.         cout << " #" << name -> id << (star_token_opt ? "." : "");
  977.         Unicode::Cout(star_token_opt ? lex_stream.Name(star_token_opt) : L"");
  978.         cout << "\n";
  979.         name -> Print(lex_stream);
  980.     }
  981.  
  982.     void AstCompilationUnit::Print(LexStream& lex_stream)
  983.     {
  984.         cout << "\nAST structure for ";
  985.         Unicode::Cout(lex_stream.FileName());
  986.         cout << ":\n\n";
  987.         cout << "#" << this -> id << " (CompilationUnit):  "
  988.              << "#" << (package_declaration_opt ? package_declaration_opt -> id : 0);
  989.         cout << " (";
  990.         for (int i = 0; i < this -> NumImportDeclarations(); i++)
  991.             cout << " #" << this -> ImportDeclaration(i) -> id;
  992.         cout << " ) (";
  993.         for (int k = 0; k < this -> NumTypeDeclarations(); k++)
  994.             cout << " #" << this -> TypeDeclaration(k) -> id;
  995.         cout << ")\n";
  996.  
  997.         if (package_declaration_opt)
  998.             package_declaration_opt -> Print(lex_stream);
  999.         for (int m = 0; m < this -> NumImportDeclarations(); m++)
  1000.             this -> ImportDeclaration(m) -> Print(lex_stream);
  1001.         for (int n = 0; n < this -> NumTypeDeclarations(); n++)
  1002.             this -> TypeDeclaration(n) -> Print(lex_stream);
  1003.     }
  1004.  
  1005.     void AstModifier::Print(LexStream& lex_stream)
  1006.     {
  1007.         cout << "#" << this -> id << " (Modifier):  ";
  1008.         Unicode::Cout(lex_stream.Name(modifier_kind_token));
  1009.         cout << "\n";
  1010.     }
  1011.  
  1012.     void AstEmptyDeclaration::Print(LexStream& lex_stream)
  1013.     {
  1014.         cout << "#" << this -> id << " (EmptyDeclaration):  ";
  1015.         Unicode::Cout(lex_stream.Name(semicolon_token));
  1016.         cout << "\n";
  1017.     }
  1018.  
  1019.     void AstClassBody::Print(LexStream& lex_stream)
  1020.     {
  1021.         cout << "#" << this -> id << " (ClassBody):  ";
  1022.         cout << "\n    {";
  1023.         for (int i = 0; i < this -> NumClassBodyDeclarations(); i++)
  1024.         {
  1025.             if (i % 10 == 0)
  1026.                  cout << "\n       ";
  1027.             cout << " #" << this -> ClassBodyDeclaration(i) -> id;
  1028.         }
  1029.         cout << "\n    }\n";
  1030.  
  1031.         for (int k = 0; k < this -> NumClassBodyDeclarations(); k++)
  1032.             this -> ClassBodyDeclaration(k) -> Print(lex_stream);
  1033.     }
  1034.  
  1035.     void AstClassDeclaration::Print(LexStream& lex_stream)
  1036.     {
  1037.         cout << "#" << this -> id << " (ClassDeclaration):  ";
  1038.         for (int i = 0; i < this -> NumClassModifiers(); i++)
  1039.         {
  1040.             Unicode::Cout(lex_stream.Name(this -> ClassModifier(i) -> modifier_kind_token));
  1041.             cout << " ";
  1042.         }
  1043.         Unicode::Cout(lex_stream.Name(class_token));
  1044.         cout << " ";
  1045.         Unicode::Cout(lex_stream.Name(identifier_token));
  1046.         cout << " #" << (super_opt ? super_opt -> id : 0);
  1047.         cout << "(";
  1048.         for (int j = 0; j < NumInterfaces(); j++)
  1049.             cout << " #" << this -> Interface(j) -> id;
  1050.         cout << ") #" << class_body -> id << "\n";
  1051.  
  1052.         if (super_opt)
  1053.             super_opt -> Print(lex_stream);
  1054.         for (int k = 0; k < NumInterfaces(); k++)
  1055.             this -> Interface(k) -> Print(lex_stream);
  1056.         class_body -> Print(lex_stream);
  1057.     }
  1058.  
  1059.     void AstArrayInitializer::Print(LexStream& lex_stream)
  1060.     {
  1061.         cout << "#" << this -> id << " (ArrayInitializer):  ";
  1062.         cout << "\n    {";
  1063.         for (int i = 0; i < NumVariableInitializers(); i++)
  1064.         {
  1065.             if (i % 10 == 0)
  1066.                  cout << "\n       ";
  1067.             cout << " #" << this -> VariableInitializer(i) -> id;
  1068.         }
  1069.         cout << "\n    }\n";
  1070.  
  1071.         for (int k = 0; k < NumVariableInitializers(); k++)
  1072.             this -> VariableInitializer(k) -> Print(lex_stream);
  1073.     }
  1074.  
  1075.     void AstBrackets::Print(LexStream& lex_stream)
  1076.     {
  1077.         cout << "#" << this -> id << " (Brackets):  []" << "\n";
  1078.     }
  1079.  
  1080.     void AstVariableDeclaratorId::Print(LexStream& lex_stream)
  1081.     {
  1082.         cout << "#" << this -> id << " (VariableDeclaratorId):  ";
  1083.         Unicode::Cout(lex_stream.Name(identifier_token));
  1084.         for (int i = 0; i < NumBrackets(); i++)
  1085.              cout << " []";
  1086.         cout << "\n";
  1087.     }
  1088.  
  1089.     void AstVariableDeclarator::Print(LexStream& lex_stream)
  1090.     {
  1091.         cout << "#" << this -> id << " (VariableDeclarator):  " << "#" << variable_declarator_name -> id << " #" <<
  1092.                 (variable_initializer_opt ? variable_initializer_opt -> id : 0) << "\n";
  1093.         variable_declarator_name -> Print(lex_stream);
  1094.         if (variable_initializer_opt)
  1095.             variable_initializer_opt -> Print(lex_stream);
  1096.         
  1097.     }
  1098.  
  1099.     void AstFieldDeclaration::Print(LexStream& lex_stream)
  1100.     {
  1101.         cout << "#" << this -> id << " (FieldDeclaration):  ";
  1102.         for (int i = 0; i < this -> NumVariableModifiers(); i++)
  1103.         {
  1104.             Unicode::Cout(lex_stream.Name(this -> VariableModifier(i) -> modifier_kind_token));
  1105.             cout << " ";
  1106.         }
  1107.         cout << " #" << type -> id;
  1108.         cout << "(";
  1109.         for (int j = 0; j < this -> NumVariableDeclarators(); j++)
  1110.             cout << " #" << this -> VariableDeclarator(j) -> id;
  1111.         cout << ") \n";
  1112.  
  1113.         type -> Print(lex_stream);
  1114.         for (int k = 0; k < this -> NumVariableDeclarators(); k++)
  1115.             this -> VariableDeclarator(k) -> Print(lex_stream);
  1116.     }
  1117.  
  1118.     void AstFormalParameter::Print(LexStream& lex_stream)
  1119.     {
  1120.         cout << "#" << this -> id << " (FormalParameter):  ";
  1121.         for (int i = 0; i < this -> NumParameterModifiers(); i++)
  1122.         {
  1123.             Unicode::Cout(lex_stream.Name(this -> ParameterModifier(i) -> modifier_kind_token));
  1124.             cout << " ";
  1125.         }
  1126.         cout << "#" << type -> id
  1127.              << " #" << variable_declarator_name -> id << "\n";
  1128.         type -> Print(lex_stream);
  1129.         variable_declarator_name -> Print(lex_stream);
  1130.     }
  1131.  
  1132.     void AstMethodDeclarator::Print(LexStream& lex_stream)
  1133.     {
  1134.         cout << "#" << this -> id << " (MethodDeclarator):  ";
  1135.         Unicode::Cout(lex_stream.Name(identifier_token));
  1136.         cout << " (";
  1137.         for (int k = 0; k < this -> NumFormalParameters(); k++)
  1138.             cout << " #" << this -> FormalParameter(k) -> id; 
  1139.         cout << " )";
  1140.         for (int i = 0; i < NumBrackets(); i++)
  1141.              cout << " []";
  1142.         cout <<  "\n";
  1143.  
  1144.         for (int j = 0; j < this -> NumFormalParameters(); j++)
  1145.             this -> FormalParameter(j) -> Print(lex_stream);
  1146.     }
  1147.  
  1148.     void AstMethodDeclaration::Print(LexStream& lex_stream)
  1149.     {
  1150.         cout << "#" << this -> id << " (MethodDeclaration):  ";
  1151.         for (int i = 0; i < this -> NumMethodModifiers(); i++)
  1152.         {
  1153.             Unicode::Cout(lex_stream.Name(this -> MethodModifier(i) -> modifier_kind_token));
  1154.             cout << " ";
  1155.         }
  1156.         cout << " #" << type -> id
  1157.              << " #" << method_declarator -> id;
  1158.         cout << " throws: (";
  1159.         for (int j = 0; j < this -> NumThrows(); j++)
  1160.             cout << " #" << this -> Throw(j) -> id;
  1161.         cout << ") #" << method_body -> id << "\n";
  1162.  
  1163.         type -> Print(lex_stream);
  1164.         method_declarator -> Print(lex_stream);
  1165.         for (int k = 0; k < this -> NumThrows(); k++)
  1166.             this -> Throw(k) -> Print(lex_stream);
  1167.         method_body -> Print(lex_stream);
  1168.     }
  1169.  
  1170.     void AstStaticInitializer::Print(LexStream& lex_stream)
  1171.     {
  1172.         cout << "#" << this -> id << " (StaticInitializer):  ";
  1173.         Unicode::Cout(lex_stream.Name(static_token));
  1174.         cout << " #" << block -> id << "\n";
  1175.         block -> Print(lex_stream);
  1176.     }
  1177.  
  1178.     void AstThisCall::Print(LexStream& lex_stream)
  1179.     {
  1180.         cout << "#" << this -> id << " (ThisCall):  ";
  1181.         Unicode::Cout(lex_stream.Name(this_token));
  1182.         cout << " (";
  1183.         for (int i = 0; i < this -> NumArguments(); i++)
  1184.             cout << " #" << this -> Argument(i) -> id;
  1185.         cout << " ) \n";
  1186.         
  1187.         for (int j = 0; j < NumArguments(); j++)
  1188.             this -> Argument(j) -> Print(lex_stream);
  1189.     }
  1190.  
  1191.     void AstSuperCall::Print(LexStream& lex_stream)
  1192.     {
  1193.         cout << "#" << this -> id << " (SuperCall):  ";
  1194.         if (base_opt)
  1195.         {
  1196.             cout << "#" << base_opt -> id;
  1197.             Unicode::Cout(lex_stream.Name(dot_token_opt));
  1198.         }
  1199.         Unicode::Cout(lex_stream.Name(super_token));
  1200.         cout << " (";
  1201.         for (int i = 0; i < this -> NumArguments(); i++)
  1202.             cout << " #" << this -> Argument(i) -> id;
  1203.         cout << " ) \n";
  1204.         base_opt -> Print(lex_stream);
  1205.  
  1206.         for (int j = 0; j < NumArguments(); j++)
  1207.             this -> Argument(j) -> Print(lex_stream);
  1208.     }
  1209.  
  1210.     void AstConstructorBlock::Print(LexStream& lex_stream)
  1211.     {
  1212.         cout << "#" << this -> id << " (ConstructorBlock):  ";
  1213.         if (explicit_constructor_invocation_opt)
  1214.              cout << " #" << explicit_constructor_invocation_opt -> id;
  1215.         else cout << " #0";
  1216.         cout << " #" << block -> id
  1217.              << "\n";
  1218.  
  1219.         if (explicit_constructor_invocation_opt)
  1220.             explicit_constructor_invocation_opt -> Print(lex_stream);
  1221.         block -> Print(lex_stream);
  1222.     }
  1223.  
  1224.     void AstConstructorDeclaration::Print(LexStream& lex_stream)
  1225.     {
  1226.         cout << "#" << this -> id << " (ConstructorDeclaration):  ";
  1227.         for (int i = 0; i < this -> NumConstructorModifiers(); i++)
  1228.         {
  1229.             Unicode::Cout(lex_stream.Name(this -> ConstructorModifier(i) -> modifier_kind_token));
  1230.             cout << " ";
  1231.         }
  1232.         cout << " #" << constructor_declarator -> id;
  1233.         cout << " throws: (";
  1234.         for (int j = 0; j < this -> NumThrows(); j++)
  1235.             cout << " #" << this -> Throw(j) -> id;
  1236.         cout << ") #" << constructor_body -> id
  1237.              << "\n";
  1238.  
  1239.         constructor_declarator -> Print(lex_stream);
  1240.         for (int k = 0; k < this -> NumThrows(); k++)
  1241.             this -> Throw(k) -> Print(lex_stream);
  1242.         constructor_body -> Print(lex_stream);
  1243.     }
  1244.  
  1245.     void AstInterfaceDeclaration::Print(LexStream& lex_stream)
  1246.     {
  1247.         cout << "#" << this -> id << " (InterfaceDeclaration):  ";
  1248.         for (int i = 0; i < this -> NumInterfaceModifiers(); i++)
  1249.         {
  1250.             Unicode::Cout(lex_stream.Name(this -> InterfaceModifier(i) -> modifier_kind_token));
  1251.             cout << " ";
  1252.         }
  1253.         Unicode::Cout(lex_stream.Name(interface_token));
  1254.         cout << " ";
  1255.         Unicode::Cout(lex_stream.Name(identifier_token));
  1256.         cout << "(";
  1257.         for (int j = 0; j < NumExtendsInterfaces(); j++)
  1258.             cout << " #" << this -> ExtendsInterface(j) -> id;
  1259.         cout << ") {";
  1260.         for (int m = 0; m < NumInterfaceMemberDeclarations(); m++)
  1261.             cout << " #" << this -> InterfaceMemberDeclaration(m) -> id;
  1262.         cout << "}\n";
  1263.  
  1264.         for (int k = 0; k < NumExtendsInterfaces(); k++)
  1265.             this -> ExtendsInterface(k) -> Print(lex_stream);
  1266.         for (int n = 0; n < NumInterfaceMemberDeclarations(); n++)
  1267.             this -> InterfaceMemberDeclaration(n) -> Print(lex_stream);
  1268.     }
  1269.  
  1270.     void AstLocalVariableDeclarationStatement::Print(LexStream& lex_stream)
  1271.     {
  1272.         cout << "#" << this -> id << " (LocalVariableDeclarationStatement):  ";
  1273.         for (int i = 0; i < this -> NumLocalModifiers(); i++)
  1274.         {
  1275.             Unicode::Cout(lex_stream.Name(this -> LocalModifier(i) -> modifier_kind_token));
  1276.             cout << " ";
  1277.         }
  1278.         cout << "#" << type -> id;
  1279.         cout << "(";
  1280.         for (int j = 0; j < this -> NumVariableDeclarators(); j++)
  1281.             cout << " #" << this -> VariableDeclarator(j) -> id;
  1282.         cout << ") \n";
  1283.  
  1284.         type -> Print(lex_stream);
  1285.         for (int k = 0; k < this -> NumVariableDeclarators(); k++)
  1286.             this -> VariableDeclarator(k) -> Print(lex_stream);
  1287.     }
  1288.  
  1289.     void AstIfStatement::Print(LexStream& lex_stream)
  1290.     {
  1291.         cout << "#" << this -> id << " (IfStatement):  ";
  1292.         Unicode::Cout(lex_stream.Name(if_token));
  1293.         cout << " ( #" << expression -> id << " ) #" << true_statement -> id;
  1294.         if (false_statement_opt)
  1295.             cout << " else #" << false_statement_opt -> id;
  1296.         else cout << " #0";
  1297.         cout << "\n";
  1298.  
  1299.         expression -> Print(lex_stream);
  1300.         true_statement -> Print(lex_stream);
  1301.         if (false_statement_opt)
  1302.             false_statement_opt -> Print(lex_stream);
  1303.     }
  1304.  
  1305.     void AstEmptyStatement::Print(LexStream& lex_stream)
  1306.     {
  1307.         cout << "#" << this -> id << " (EmptyStatement):  ";
  1308.         Unicode::Cout(lex_stream.Name(semicolon_token));
  1309.         cout << "\n";
  1310.     }
  1311.  
  1312.     void AstExpressionStatement::Print(LexStream& lex_stream)
  1313.     {
  1314.         cout << "#" << this -> id << " (ExpressionStatement):  " << "#" << expression -> id << "\n";
  1315.         expression -> Print(lex_stream);
  1316.     }
  1317.  
  1318.     void AstCaseLabel::Print(LexStream& lex_stream)
  1319.     {
  1320.         cout << "#" << this -> id << " (CaseLabel):  ";
  1321.         Unicode::Cout(lex_stream.Name(case_token));
  1322.         cout << " #" << expression -> id << ":\n";
  1323.         expression -> Print(lex_stream);
  1324.         cout << "    map_index: " << map_index << "\n";
  1325.     }
  1326.  
  1327.     void AstDefaultLabel::Print(LexStream& lex_stream)
  1328.     {
  1329.         cout << "#" << this -> id << " (DefaultLabel):  ";
  1330.         Unicode::Cout(lex_stream.Name(default_token));
  1331.         cout << ":\n";
  1332.     }
  1333.  
  1334.     void AstSwitchBlockStatement::Print(LexStream& lex_stream)
  1335.     {
  1336.         cout << "#" << this -> id << " (SwitchBlockStatement): ";
  1337.         for (int i = 0; i < NumSwitchLabels(); i++)
  1338.         {
  1339.             if (i % 10 == 0)
  1340.                  cout << "\n        ";
  1341.             cout << " #" << this -> SwitchLabel(i) -> id << ':';
  1342.         }
  1343.         cout << "\n";
  1344.         for (int k = 0; k < NumStatements(); k++)
  1345.         {
  1346.             if (k % 10 == 0)
  1347.                  cout << "\n            ";
  1348.             cout << " #" << this -> Statement(k) -> id;
  1349.         }
  1350.         cout << "\n";
  1351.  
  1352.         for (int j = 0; j < NumSwitchLabels(); j++)
  1353.             this -> SwitchLabel(j) -> Print(lex_stream);
  1354.         for (int l = 0; l < NumStatements(); l++)
  1355.             this -> Statement(l) -> Print(lex_stream);
  1356.     }
  1357.  
  1358.     void AstSwitchStatement::Print(LexStream& lex_stream)
  1359.     {
  1360.         cout << "#" << this -> id << " (SwitchStatement):  ";
  1361.         Unicode::Cout(lex_stream.Name(switch_token));
  1362.         cout << " ( #" << expression -> id << " ) #" << switch_block -> id << "\n";
  1363.  
  1364.         cout << "default case: index " << default_case.index << "\n";
  1365.         for (int i = 0; i < map.Length(); i++)
  1366.         {
  1367.             cout << "map: " << i << "  index: " << map[i] -> index << "  value: " << map[i] -> Value() << "\n";   
  1368.         }
  1369.  
  1370.         expression -> Print(lex_stream);
  1371.         switch_block -> Print(lex_stream);
  1372.     }
  1373.  
  1374.     void AstWhileStatement::Print(LexStream& lex_stream)
  1375.     {
  1376.         cout << "#" << this -> id << " (WhileStatement):  ";
  1377.         Unicode::Cout(lex_stream.Name(while_token));
  1378.         cout << " ( #" << expression -> id << " ) #" << statement -> id << "\n";
  1379.         expression -> Print(lex_stream);
  1380.         statement -> Print(lex_stream);
  1381.     }
  1382.  
  1383.     void AstDoStatement::Print(LexStream& lex_stream)
  1384.     {
  1385.         cout << "#" << this -> id << " (DoStatement):  ";
  1386.         Unicode::Cout(lex_stream.Name(do_token));
  1387.         cout << " { #" << statement -> id << " } ";
  1388.         Unicode::Cout(lex_stream.Name(while_token));
  1389.         cout << " ( #" << expression -> id << " ) #\n";
  1390.  
  1391.         statement -> Print(lex_stream);
  1392.         expression -> Print(lex_stream);
  1393.     }
  1394.  
  1395.     void AstForStatement::Print(LexStream& lex_stream)
  1396.     {
  1397.         cout << "#" << this -> id << " (ForStatement):  (";
  1398.         Unicode::Cout(lex_stream.Name(for_token));
  1399.         for (int i = 0; i < this -> NumForInitStatements(); i++)
  1400.             cout << " #" << this -> ForInitStatement(i) -> id;
  1401.         cout << "; #" << (end_expression_opt ? end_expression_opt -> id : 0) << ";";
  1402.         for (int k = 0; k < this -> NumForInitStatements(); k++)
  1403.             cout << " #" << this -> ForUpdateStatement(k) -> id;
  1404.         cout << ") #" << statement -> id << "\n";
  1405.  
  1406.         for (int m = 0; m < this -> NumForInitStatements(); m++)
  1407.             this -> ForInitStatement(m) -> Print(lex_stream);
  1408.         if (end_expression_opt)
  1409.             end_expression_opt -> Print(lex_stream);
  1410.         for (int n = 0; n < this -> NumForUpdateStatements(); n++)
  1411.             this -> ForUpdateStatement(n) -> Print(lex_stream);
  1412.         statement -> Print(lex_stream);
  1413.     }
  1414.  
  1415.     void AstBreakStatement::Print(LexStream& lex_stream)
  1416.     {
  1417.         cout << "#" << this -> id << " (BreakStatement):  ";
  1418.         Unicode::Cout(lex_stream.Name(break_token));
  1419.         cout << " ";
  1420.         Unicode::Cout(identifier_token_opt ? lex_stream.Name(identifier_token_opt) : L"");
  1421.         cout << " at nesting_level " << nesting_level << "\n";
  1422.     }
  1423.  
  1424.     void AstContinueStatement::Print(LexStream& lex_stream)
  1425.     {
  1426.         cout << "#" << this -> id << " (ContinueStatement):  ";
  1427.         Unicode::Cout(lex_stream.Name(continue_token));
  1428.         cout << " ";
  1429.         Unicode::Cout(identifier_token_opt ? lex_stream.Name(identifier_token_opt) : L"");
  1430.         cout << " at nesting_level " << nesting_level << "\n";
  1431.     }
  1432.  
  1433.     void AstReturnStatement::Print(LexStream& lex_stream)
  1434.     {
  1435.         cout << "#" << this -> id << " (ReturnStatement):  ";
  1436.         Unicode::Cout(lex_stream.Name(return_token));
  1437.         cout << " "
  1438.              << " #" << (expression_opt ? expression_opt -> id : 0) << "\n";
  1439.         if (expression_opt)
  1440.             expression_opt -> Print(lex_stream);
  1441.     }
  1442.  
  1443.     void AstThrowStatement::Print(LexStream& lex_stream)
  1444.     {
  1445.         cout << "#" << this -> id << " (ThrowStatement):  ";
  1446.         Unicode::Cout(lex_stream.Name(throw_token));
  1447.         cout << " "
  1448.              << " #" << expression -> id << "\n";
  1449.         expression -> Print(lex_stream);
  1450.     }
  1451.  
  1452.     void AstSynchronizedStatement::Print(LexStream& lex_stream)
  1453.     {
  1454.         cout << "#" << this -> id << " (SynchronizedStatement):  ";
  1455.         Unicode::Cout(lex_stream.Name(synchronized_token));
  1456.         cout << " ( #" << expression -> id
  1457.              << " ) #" << block -> id << "\n";
  1458.         expression -> Print(lex_stream);
  1459.         block -> Print(lex_stream);
  1460.     }
  1461.  
  1462.     void AstCatchClause::Print(LexStream& lex_stream)
  1463.     {
  1464.         cout << "#" << this -> id << " (CatchClause):  ";
  1465.         Unicode::Cout(lex_stream.Name(catch_token));
  1466.         cout << " #" << formal_parameter -> id
  1467.              << " #" << block -> id << "\n";
  1468.         formal_parameter -> Print(lex_stream);
  1469.         block -> Print(lex_stream);
  1470.     }
  1471.  
  1472.     void AstFinallyClause::Print(LexStream& lex_stream)
  1473.     {
  1474.         cout << "#" << this -> id << " (FinallyClause):  ";
  1475.         Unicode::Cout(lex_stream.Name(finally_token));
  1476.         cout << " #" << block -> id << "\n";
  1477.         block -> Print(lex_stream);
  1478.     }
  1479.  
  1480.     void AstTryStatement::Print(LexStream& lex_stream)
  1481.     {
  1482.         cout << "#" << this -> id << " (TryStatement):  ";
  1483.         Unicode::Cout(lex_stream.Name(try_token));
  1484.         cout << " #" << block -> id
  1485.              << " catch (";
  1486.         for (int i = 0; i < this -> NumCatchClauses(); i++)
  1487.             cout << " #" << this -> CatchClause(i) -> id;
  1488.         cout << ") finally " << "#" << (finally_clause_opt ? finally_clause_opt -> id : 0) << "\n";
  1489.  
  1490.         block -> Print(lex_stream);
  1491.         for (int k = 0; k < this -> NumCatchClauses(); k++)
  1492.             this -> CatchClause(k) -> Print(lex_stream);
  1493.         if (finally_clause_opt)
  1494.             finally_clause_opt -> Print(lex_stream);
  1495.     }
  1496.  
  1497.     void AstIntegerLiteral::Print(LexStream& lex_stream)
  1498.     {
  1499.         cout << "#" << this -> id << " (IntegerLiteral):  ";
  1500.         Unicode::Cout(lex_stream.Name(integer_literal_token));
  1501.         cout << "\n";
  1502.     }
  1503.  
  1504.     void AstLongLiteral::Print(LexStream& lex_stream)
  1505.     {
  1506.         cout << "#" << this -> id << " (LongLiteral):  ";
  1507.         Unicode::Cout(lex_stream.Name(long_literal_token));
  1508.         cout << "\n";
  1509.     }
  1510.  
  1511.     void AstFloatingPointLiteral::Print(LexStream& lex_stream)
  1512.     {
  1513.         cout << "#" << this -> id << " (FloatingPointLiteral):  ";
  1514.         Unicode::Cout(lex_stream.Name(floating_point_literal_token));
  1515.         cout << "\n";
  1516.     }
  1517.  
  1518.     void AstDoubleLiteral::Print(LexStream& lex_stream)
  1519.     {
  1520.         cout << "#" << this -> id << " (DoubleLiteral):  ";
  1521.         Unicode::Cout(lex_stream.Name(double_literal_token));
  1522.         cout << "\n";
  1523.     }
  1524.  
  1525.     void AstTrueLiteral::Print(LexStream& lex_stream)
  1526.     {
  1527.         cout << "#" << this -> id << " (TrueLiteral):  ";
  1528.         Unicode::Cout(lex_stream.Name(true_literal_token));
  1529.         cout << "\n";
  1530.     }
  1531.  
  1532.     void AstFalseLiteral::Print(LexStream& lex_stream)
  1533.     {
  1534.         cout << "#" << this -> id << " (FalseLiteral):  ";
  1535.         Unicode::Cout(lex_stream.Name(false_literal_token));
  1536.         cout << "\n";
  1537.     }
  1538.  
  1539.     void AstStringLiteral::Print(LexStream& lex_stream)
  1540.     {
  1541.         cout << "#" << this -> id << " (StringLiteral):  ";
  1542.         Unicode::Cout(lex_stream.Name(string_literal_token));
  1543.         cout << "\n";
  1544.     }
  1545.  
  1546.     void AstCharacterLiteral::Print(LexStream& lex_stream)
  1547.     {
  1548.         cout << "#" << this -> id << " (CharacterLiteral):  ";
  1549.         Unicode::Cout(lex_stream.Name(character_literal_token));
  1550.         cout << "\n";
  1551.     }
  1552.  
  1553.     void AstNullLiteral::Print(LexStream& lex_stream)
  1554.     {
  1555.         cout << "#" << this -> id << " (NullLiteral):  ";
  1556.         Unicode::Cout(lex_stream.Name(null_token));
  1557.         cout << "\n";
  1558.     }
  1559.  
  1560.     void AstThisExpression::Print(LexStream& lex_stream)
  1561.     {
  1562.         cout << "#" << this -> id << " (ThisExpression):  ";
  1563.         Unicode::Cout(lex_stream.Name(this_token));
  1564.         cout << "\n";
  1565.     }
  1566.  
  1567.     void AstSuperExpression::Print(LexStream& lex_stream)
  1568.     {
  1569.         cout << "#" << this -> id << " (SuperExpression):  ";
  1570.         Unicode::Cout(lex_stream.Name(super_token));
  1571.         cout << "\n";
  1572.     }
  1573.  
  1574.     void AstParenthesizedExpression::Print(LexStream& lex_stream)
  1575.     {
  1576.         cout << "#" << this -> id << " (ParenthesizedExpression):  ";
  1577.         Unicode::Cout(lex_stream.Name(left_parenthesis_token));
  1578.         cout << "#" << expression -> id;
  1579.         Unicode::Cout(lex_stream.Name(right_parenthesis_token));
  1580.         cout << "\n";
  1581.     }
  1582.  
  1583.     void AstTypeExpression::Print(LexStream& lex_stream)
  1584.     {
  1585.         cout << "#" << this -> id << " (TypeExpression):  "
  1586.              << " #" << type -> id << "\n";
  1587.         type -> Print(lex_stream);
  1588.     }
  1589.  
  1590.     void AstClassInstanceCreationExpression::Print(LexStream& lex_stream)
  1591.     {
  1592.         cout << "#" << this -> id << " (ClassInstanceCreationExpression):  ";
  1593.         if (dot_token_opt)
  1594.         {
  1595.             cout << "#" << base_opt -> id;
  1596.             Unicode::Cout(lex_stream.Name(dot_token_opt));
  1597.         }
  1598.         Unicode::Cout(lex_stream.Name(new_token));
  1599.         cout << " #" << class_type -> id;
  1600.         cout << " (";
  1601.         for (int i = 0; i < this -> NumArguments(); i++)
  1602.             cout << " #" << this -> Argument(i) -> id;
  1603.         cout << " ) \n";
  1604.         cout << "#" << (class_body_opt ? class_body_opt -> id : 0) << "\n";
  1605.  
  1606.         if (dot_token_opt /* base_opt - see ast.h for explanation */)
  1607.             base_opt -> Print(lex_stream);
  1608.         class_type -> Print(lex_stream);
  1609.         for (int j = 0; j < NumArguments(); j++)
  1610.             this -> Argument(j) -> Print(lex_stream);
  1611.         if (class_body_opt)
  1612.             class_body_opt -> Print(lex_stream);
  1613.     }
  1614.  
  1615.     void AstDimExpr::Print(LexStream& lex_stream)
  1616.     {
  1617.         cout << "#" << this -> id << " (DimExpr):  [ #" << expression -> id << " ]\n";
  1618.         expression -> Print(lex_stream);
  1619.     }
  1620.  
  1621.     void AstArrayCreationExpression::Print(LexStream& lex_stream)
  1622.     {
  1623.         cout << "#" << this -> id << " (ArrayCreationExpression):  ";
  1624.         Unicode::Cout(lex_stream.Name(new_token));
  1625.         cout << " #" << array_type -> id;
  1626.         for (int i = 0; i < NumDimExprs(); i++)
  1627.             cout << " [#" << DimExpr(i) -> id << "]";
  1628.         for (int k = 0; k < NumBrackets(); k++)
  1629.              cout << " []";
  1630.         cout << " ";
  1631.         cout << "#" << (array_initializer_opt ? array_initializer_opt -> id : 0) << "\n";
  1632.  
  1633.         array_type -> Print(lex_stream);
  1634.         for (int j = 0; j < this -> NumDimExprs(); j++)
  1635.             DimExpr(j) -> Print(lex_stream);
  1636.     }
  1637.  
  1638.     void AstFieldAccess::Print(LexStream& lex_stream)
  1639.     {
  1640.         cout << "#" << this -> id << " (FieldAccess):  "
  1641.              << " #" << base -> id << " ";
  1642.         Unicode::Cout(lex_stream.Name(identifier_token));
  1643.         cout << "\n";
  1644.  
  1645.         base -> Print(lex_stream);
  1646.     }
  1647.  
  1648.     void AstMethodInvocation::Print(LexStream& lex_stream)
  1649.     {
  1650.         cout << "#" << this -> id << " (MethodInvocation):  "
  1651.              << "#" << method -> id;
  1652.         cout << " (";
  1653.         for (int i = 0; i < this -> NumArguments(); i++)
  1654.             cout << " #" << this -> Argument(i) -> id;
  1655.         cout << " ) \n";
  1656.         
  1657.         method -> Print(lex_stream);
  1658.         for (int j = 0; j < NumArguments(); j++)
  1659.             this -> Argument(j) -> Print(lex_stream);
  1660.     }
  1661.  
  1662.     void AstArrayAccess::Print(LexStream& lex_stream)
  1663.     {
  1664.         cout << "#" << this -> id << " (ArrayAccess):  "
  1665.              << "#" << base -> id
  1666.              << " [ #" << expression -> id << " ]\n";
  1667.  
  1668.         base -> Print(lex_stream);
  1669.         expression -> Print(lex_stream);
  1670.     }
  1671.  
  1672.     void AstPostUnaryExpression::Print(LexStream& lex_stream)
  1673.     {
  1674.         cout << "#" << this -> id << " (PostUnaryExpression):  "
  1675.              << "#" << expression -> id;
  1676.         Unicode::Cout(lex_stream.Name(post_operator_token));
  1677.         cout << "\n";
  1678.  
  1679.         expression -> Print(lex_stream);
  1680.     }
  1681.  
  1682.     void AstPreUnaryExpression::Print(LexStream& lex_stream)
  1683.     {
  1684.         cout << "#" << this -> id << " (PreUnaryExpression):  ";
  1685.         Unicode::Cout(lex_stream.Name(pre_operator_token));
  1686.         cout << " #" << expression -> id << "\n";
  1687.  
  1688.         expression -> Print(lex_stream);
  1689.     }
  1690.  
  1691.     void AstCastExpression::Print(LexStream& lex_stream)
  1692.     {
  1693.         if (left_parenthesis_token_opt)
  1694.         {
  1695.           cout << "#" << this -> id << (kind == CAST ? " (CastExpression: just cast):  " : " (CastExpression: check and cast):  ")
  1696.                  << "( #" << (type_opt ? type_opt -> id : 0);
  1697.             for (int i = 0; i < NumBrackets(); i++)
  1698.                  cout << " []";
  1699.             cout << " ) #" << expression -> id << "\n";
  1700.             if (type_opt)
  1701.                 type_opt -> Print(lex_stream);
  1702.         }
  1703.         else
  1704.         {
  1705.             cout << "#" << this -> id << " (Java Semantic Cast to " << Type() -> Name()
  1706.                  << "):  #" << expression -> id << "\n";
  1707.         }
  1708.  
  1709.         expression -> Print(lex_stream);
  1710.     }
  1711.  
  1712.     void AstBinaryExpression::Print(LexStream& lex_stream)
  1713.     {
  1714.         cout << "#" << this -> id << " (BinaryExpression):  "
  1715.              << "#" << left_expression -> id << " ";
  1716.         Unicode::Cout(lex_stream.Name(binary_operator_token));
  1717.         cout << " #" << right_expression -> id << "\n";
  1718.  
  1719.         left_expression -> Print(lex_stream);
  1720.         right_expression -> Print(lex_stream);
  1721.     }
  1722.  
  1723.     void AstConditionalExpression::Print(LexStream& lex_stream)
  1724.     {
  1725.         cout << "#" << this -> id << " (ConditionalExpression):  "
  1726.              << "#" << test_expression -> id
  1727.              << " ? #" << true_expression -> id
  1728.              << " : #" << false_expression -> id << "\n";
  1729.  
  1730.         test_expression -> Print(lex_stream);
  1731.         true_expression -> Print(lex_stream);
  1732.         false_expression -> Print(lex_stream);
  1733.     }
  1734.  
  1735.     void AstAssignmentExpression::Print(LexStream& lex_stream)
  1736.     {
  1737.         cout << "#" << this -> id << " (AssignmentExpression):  "
  1738.              << "#" << left_hand_side -> id << " ";
  1739.         Unicode::Cout(lex_stream.Name(assignment_operator_token));
  1740.         cout << " #" << expression -> id << "\n";
  1741.  
  1742.         left_hand_side -> Print(lex_stream);
  1743.         expression -> Print(lex_stream);
  1744.     }
  1745.  
  1746. #endif
  1747.  
  1748. Ast::~Ast()
  1749. {
  1750.     assert(0);
  1751. }
  1752.  
  1753. AstStatement::~AstStatement()
  1754. {
  1755.     assert(0);
  1756. }
  1757.  
  1758. AstExpression::~AstExpression()
  1759. {
  1760.     assert(0);
  1761. }
  1762.  
  1763. AstBlock::~AstBlock()
  1764. {
  1765.     assert(0);
  1766.     //    delete block_statements;
  1767. }
  1768.  
  1769. AstPrimitiveType::~AstPrimitiveType()
  1770. {
  1771.     assert(0);
  1772. }
  1773.  
  1774. AstArrayType::~AstArrayType()
  1775. {
  1776.     assert(0);
  1777.     //    delete type;
  1778.     //    delete brackets;
  1779. }
  1780.  
  1781. AstSimpleName::~AstSimpleName()
  1782. {
  1783.     assert(0);
  1784.     //    delete resolution_opt;
  1785. }
  1786.  
  1787. AstPackageDeclaration::~AstPackageDeclaration()
  1788. {
  1789.     assert(0);
  1790.     //    delete name;
  1791. }
  1792.  
  1793. AstImportDeclaration::~AstImportDeclaration()
  1794. {
  1795.     assert(0);
  1796.     //    delete name;
  1797. }
  1798.  
  1799. AstCompilationUnit::~AstCompilationUnit()
  1800. {
  1801.     assert(0);
  1802.     //    delete package_declaration_opt;
  1803.     //    delete import_declarations;
  1804.     //    delete type_declarations;
  1805. }
  1806.  
  1807. AstModifier::~AstModifier()
  1808. {
  1809.     assert(0);
  1810. }
  1811.  
  1812. AstEmptyDeclaration::~AstEmptyDeclaration()
  1813. {
  1814.     assert(0);
  1815. }
  1816.  
  1817. AstClassBody::~AstClassBody()
  1818. {
  1819.     assert(0);
  1820.     //    delete default_constructor;
  1821.     //    delete instance_variables;
  1822.     //    delete class_variables;
  1823.     //    delete methods;
  1824.     //    delete constructors;
  1825.     //    delete static_initializers;
  1826.     //    delete inner_classes;
  1827.     //    delete inner_interfaces;
  1828.     //    delete blocks;
  1829.     //    delete class_body_declarations;
  1830.     //    delete this_block;
  1831. }
  1832.  
  1833. AstClassDeclaration::~AstClassDeclaration()
  1834. {
  1835.     assert(0);
  1836.     //    delete class_modifiers;
  1837.     //    delete super_opt;
  1838.     //    delete interfaces;
  1839.     //    delete class_body;
  1840. }
  1841.  
  1842. AstArrayInitializer::~AstArrayInitializer()
  1843. {
  1844.     assert(0);
  1845.     //    delete variable_initializers;
  1846. }
  1847.  
  1848. AstBrackets::~AstBrackets()
  1849. {
  1850.     assert(0);
  1851. }
  1852.  
  1853. AstVariableDeclaratorId::~AstVariableDeclaratorId()
  1854. {
  1855.     assert(0);
  1856.     //    delete brackets;
  1857. }
  1858.  
  1859. AstVariableDeclarator::~AstVariableDeclarator()
  1860. {
  1861.     assert(0);
  1862.     //    delete variable_declarator_name;
  1863.     //    delete variable_initializer_opt;
  1864. }
  1865.  
  1866. AstFieldDeclaration::~AstFieldDeclaration()
  1867. {
  1868.     assert(0);
  1869.     //    delete variable_modifiers;
  1870.     //    delete type;
  1871.     //    delete variable_declarators;
  1872. }
  1873.  
  1874. AstFormalParameter::~AstFormalParameter()
  1875. {
  1876.     assert(0);
  1877.     //    delete parameter_modifiers;
  1878.     //    delete type;
  1879.     //    delete variable_declarator_name;
  1880. }
  1881.  
  1882. AstMethodDeclarator::~AstMethodDeclarator()
  1883. {
  1884.     assert(0);
  1885.     //    delete formal_parameters;
  1886.     //    delete brackets;
  1887. }
  1888.  
  1889. AstMethodDeclaration::~AstMethodDeclaration()
  1890. {
  1891.     assert(0);
  1892.     //    delete method_modifiers;
  1893.     //    delete type;
  1894.     //    delete method_declarator;
  1895.     //    delete throws;
  1896.     //    delete method_body;
  1897. }
  1898.  
  1899. AstStaticInitializer::~AstStaticInitializer()
  1900. {
  1901.     assert(0);
  1902.     //    delete block;
  1903. }
  1904.  
  1905. AstThisCall::~AstThisCall()
  1906. {
  1907.     assert(0);
  1908.     //    delete arguments;
  1909.     //    delete base_opt;
  1910.     //    delete local_arguments_opt;
  1911. }
  1912.  
  1913. AstSuperCall::~AstSuperCall()
  1914. {
  1915.     assert(0);
  1916.     //    delete base_opt;
  1917.     //    delete arguments;
  1918.     //    delete local_arguments_opt;
  1919. }
  1920.  
  1921. AstConstructorBlock::~AstConstructorBlock()
  1922. {
  1923.     assert(0);
  1924.     //    delete explicit_constructor_invocation_opt;
  1925.     //    delete block;
  1926.     //    delete local_init_block;
  1927.     //    delete original_constructor_invocation;
  1928. }
  1929.  
  1930. AstConstructorDeclaration::~AstConstructorDeclaration()
  1931. {
  1932.     assert(0);
  1933.     //    delete constructor_modifiers;
  1934.     //    delete constructor_declarator;
  1935.     //    delete throws;
  1936.     //    delete constructor_body;
  1937. }
  1938.  
  1939. AstInterfaceDeclaration::~AstInterfaceDeclaration()
  1940. {
  1941.     assert(0);
  1942.     //    delete class_variables;
  1943.     //    delete abstract_methods;
  1944.     //    delete inner_classes;
  1945.     //    delete inner_interfaces;
  1946.     //    delete interface_modifiers;
  1947.     //    delete extends_interfaces;
  1948.     //    delete interface_member_declarations;
  1949. }
  1950.  
  1951. AstLocalVariableDeclarationStatement::~AstLocalVariableDeclarationStatement()
  1952. {
  1953.     assert(0);
  1954.     //    delete local_modifiers;
  1955.     //    delete type;
  1956.     //    delete variable_declarators;
  1957. }
  1958.  
  1959. AstIfStatement::~AstIfStatement()
  1960. {
  1961.     assert(0);
  1962.     //    delete expression;
  1963.     //    delete true_statement;
  1964.     //    delete false_statement_opt;
  1965. }
  1966.  
  1967. AstEmptyStatement::~AstEmptyStatement()
  1968. {
  1969.     assert(0);
  1970. }
  1971.  
  1972. AstExpressionStatement::~AstExpressionStatement()
  1973. {
  1974.     assert(0);
  1975.     //    delete expression;
  1976. }
  1977.  
  1978. AstCaseLabel::~AstCaseLabel()
  1979. {
  1980.     assert(0);
  1981.     //    delete expression;
  1982. }
  1983.  
  1984. AstDefaultLabel::~AstDefaultLabel()
  1985. {
  1986.     assert(0);
  1987. }
  1988.  
  1989. AstSwitchBlockStatement::~AstSwitchBlockStatement()
  1990. {
  1991.     assert(0);
  1992.     //    delete switch_labels;
  1993.     //    delete block_statements;
  1994. }
  1995.  
  1996. AstSwitchStatement::~AstSwitchStatement()
  1997. {
  1998.     assert(0);
  1999.     //    delete expression;
  2000.     //    delete switch_block;
  2001. }
  2002.  
  2003. AstWhileStatement::~AstWhileStatement()
  2004. {
  2005.     assert(0);
  2006.     //    delete expression;
  2007.     //    delete statement;
  2008. }
  2009.  
  2010. AstDoStatement::~AstDoStatement()
  2011. {
  2012.     assert(0);
  2013.     //    delete statement;
  2014.     //    delete expression;
  2015. }
  2016.  
  2017. AstForStatement::~AstForStatement()
  2018. {
  2019.     assert(0);
  2020.     //    delete for_init_statements;
  2021.     //    delete end_expression_opt;
  2022.     //    delete for_update_statements;
  2023.     //    delete statement;
  2024. }
  2025.  
  2026. AstBreakStatement::~AstBreakStatement()
  2027. {
  2028.     assert(0);
  2029. }
  2030.  
  2031. AstContinueStatement::~AstContinueStatement()
  2032. {
  2033.     assert(0);
  2034. }
  2035.  
  2036. AstReturnStatement::~AstReturnStatement()
  2037. {
  2038.     assert(0);
  2039.     //    delete expression_opt;
  2040. }
  2041.  
  2042. AstThrowStatement::~AstThrowStatement()
  2043. {
  2044.     assert(0);
  2045.     //    delete expression;
  2046. }
  2047.  
  2048. AstSynchronizedStatement::~AstSynchronizedStatement()
  2049. {
  2050.     assert(0);
  2051.     //    delete expression;
  2052.     //    delete block;
  2053. }
  2054.  
  2055. AstCatchClause::~AstCatchClause()
  2056. {
  2057.     assert(0);
  2058.     //    delete formal_parameter;
  2059.     //    delete block;
  2060. }
  2061.  
  2062. AstFinallyClause::~AstFinallyClause()
  2063. {
  2064.     assert(0);
  2065.     //    delete block;
  2066. }
  2067.  
  2068. AstTryStatement::~AstTryStatement()
  2069. {
  2070.     assert(0);
  2071.     //    delete block;
  2072.     //    delete catch_clauses;
  2073.     //    delete finally_clause_opt;
  2074. }
  2075.  
  2076. AstIntegerLiteral::~AstIntegerLiteral()
  2077. {
  2078.     assert(0);
  2079. }
  2080.  
  2081. AstLongLiteral::~AstLongLiteral()
  2082. {
  2083.     assert(0);
  2084. }
  2085.  
  2086. AstFloatingPointLiteral::~AstFloatingPointLiteral()
  2087. {
  2088.     assert(0);
  2089. }
  2090.  
  2091. AstDoubleLiteral::~AstDoubleLiteral()
  2092. {
  2093.     assert(0);
  2094. }
  2095.  
  2096. AstTrueLiteral::~AstTrueLiteral()
  2097. {
  2098.     assert(0);
  2099. }
  2100.  
  2101. AstFalseLiteral::~AstFalseLiteral()
  2102. {
  2103.     assert(0);
  2104. }
  2105.  
  2106. AstStringLiteral::~AstStringLiteral()
  2107. {
  2108.     assert(0);
  2109. }
  2110.  
  2111. AstCharacterLiteral::~AstCharacterLiteral()
  2112. {
  2113.     assert(0);
  2114. }
  2115.  
  2116. AstNullLiteral::~AstNullLiteral()
  2117. {
  2118.     assert(0);
  2119. }
  2120.  
  2121. AstThisExpression::~AstThisExpression()
  2122. {
  2123.     assert(0);
  2124. }
  2125.  
  2126. AstSuperExpression::~AstSuperExpression()
  2127. {
  2128.     assert(0);
  2129. }
  2130.  
  2131. AstParenthesizedExpression::~AstParenthesizedExpression()
  2132. {
  2133.     assert(0);
  2134.     //    delete expression;
  2135. }
  2136.  
  2137. AstTypeExpression::~AstTypeExpression()
  2138. {
  2139.     assert(0);
  2140.     //    delete type;
  2141. }
  2142.  
  2143. AstClassInstanceCreationExpression::~AstClassInstanceCreationExpression()
  2144. {
  2145.     assert(0);
  2146.     //    delete base_opt;
  2147.     //    delete class_type;
  2148.     //    delete arguments;
  2149.     //    delete class_body_opt;
  2150.     //    delete local_arguments_opt;
  2151. }
  2152.  
  2153. AstDimExpr::~AstDimExpr()
  2154. {
  2155.     assert(0);
  2156.     //    delete expression;
  2157. }
  2158.  
  2159. AstArrayCreationExpression::~AstArrayCreationExpression()
  2160. {
  2161.     assert(0);
  2162.     //    delete array_type;
  2163.     //    delete dim_exprs;
  2164.     //    delete brackets;
  2165.     //    delete array_initializer_opt;
  2166. }
  2167.  
  2168. AstFieldAccess::~AstFieldAccess()
  2169. {
  2170.     assert(0);
  2171.     //    delete base;
  2172.     //    delete resolution_opt;
  2173. }
  2174.  
  2175. AstMethodInvocation::~AstMethodInvocation()
  2176. {
  2177.     assert(0);
  2178.     //    delete method;
  2179.     //    delete arguments;
  2180. }
  2181.  
  2182. AstArrayAccess::~AstArrayAccess()
  2183. {
  2184.     assert(0);
  2185.     //    delete base;
  2186.     //    delete expression;
  2187. }
  2188.  
  2189. AstPostUnaryExpression::~AstPostUnaryExpression()
  2190. {
  2191.     assert(0);
  2192.     //    delete expression;
  2193. }
  2194.  
  2195. AstPreUnaryExpression::~AstPreUnaryExpression()
  2196. {
  2197.     assert(0);
  2198.     //    delete expression;
  2199. }
  2200.  
  2201. AstCastExpression::~AstCastExpression()
  2202. {
  2203.     assert(0);
  2204.     //    delete type_opt;
  2205.     //    delete brackets;
  2206.     //    delete expression;
  2207. }
  2208.  
  2209. AstBinaryExpression::~AstBinaryExpression()
  2210. {
  2211.    assert(0);
  2212.    //    delete left_expression;
  2213.    //    delete right_expression;
  2214. }
  2215.  
  2216. AstConditionalExpression::~AstConditionalExpression()
  2217. {
  2218.     assert(0);
  2219.     //    delete test_expression;
  2220.     //    delete true_expression;
  2221.     //    delete false_expression;
  2222. }
  2223.  
  2224. AstAssignmentExpression::~AstAssignmentExpression()
  2225. {
  2226.     assert(0);
  2227.     //    delete left_hand_side;
  2228.     //    delete expression;
  2229. }
  2230.